home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d26 / matlab.arc / INSTALL.DOC < prev    next >
Encoding:
Text File  |  1990-09-23  |  31.8 KB  |  1,189 lines
  1.  
  2.  
  3. 11/6/83
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.                     MATLAB Installation Guide
  12.                          November, 1983
  13.  
  14.  
  15.                            Cleve Moler
  16.                  Department of Computer Science
  17.                     University of New Mexico
  18.  
  19.  
  20.  
  21.      The MATLAB tape is usually in one of two formats --  a  UNIX
  22. "tar" tape, or a "generic" tape with the following parameters:
  23.  
  24.           9 track
  25.           1600 bits per inch
  26.           no label
  27.           80 characters per record
  28.           1600 characters per block
  29.           18 files in ASCII, followed by 18 files in EBCDIC
  30.  
  31.      There are 36 files on the generic tape.  The  names  of  the
  32. first 18, and their approximate sizes, are:
  33.  
  34.           1.  INSTALL       1100 lines
  35.           2.  MAT           3900 lines
  36.           3.  LIB           3339 lines
  37.           4.  HELPER.66       75 lines
  38.           5.  HELPER.77      120 lines
  39.           6.  HELP           750 lines
  40.           7.  SYS.UNIX       900 lines
  41.           8.  SYS.VMS        260 lines
  42.           9.  SYS.TSO        200 lines
  43.          10.  SYS.CMS        350 lines
  44.          11.  SYS.DEC10      250 lines
  45.          12.  SYS.CDC        200 lines
  46.          13.  SYS.PRIME      350 lines
  47.          14.  DOC           3960 lines
  48.          15.  DEMO            21 lines
  49.          16.  DOC.NROFF     3250 lines
  50.          17.  MAT.SNGL      3850 lines
  51.          18.  LIB.SNGL      3339 lines
  52.  
  53. where a line is one 80 character record.
  54.  
  55.      The first 18 files are  in  the  ASCII  character  set.  The
  56. remaining 18 files are copies of the first 18 in EBCDIC.
  57.  
  58.      INSTALL is this document.  You can skip over it if you  have
  59. this hard copy.
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69. MATLAB Installation, page 2
  70.  
  71.  
  72.  
  73.      MAT, LIB, one of the versions  of  HELPER  and  one  of  the
  74. versions  of SYS together constitute the complete source code for
  75. the double precision version of MATLAB.
  76.  
  77.      The subroutines in MAT make up the parser  and  interpreter.
  78. They  include  a  COMMON statement which can be changed to change
  79. the amount of memory allocated to variables.
  80.  
  81.      The subroutines in LIB  include  modified  versions  of  the
  82. necessary  routines from LINPACK, EISPACK and the BLAS.  These do
  83. not contain any COMMON statements and do not have to  be  changed
  84. if the size of the stack is changed.
  85.  
  86.      There are two  versions  of  HELPER,  the  subroutine  which
  87. manages  the  help facility.  The version in HELPER.66 is written
  88. in Fortran 66 and uses sequential i/o. The version  in  HELPER.77
  89. is  written in Fortran 77 and uses character variables and direct
  90. access i/o. If your  system  supports  both  versions,  you  will
  91. probably  want  to  choose  the direct access one -- it should be
  92. much faster. If you choose the direct access  version,  you  will
  93. have  to  run a preprocessor named HELPSET, which is also in file
  94. HELPER.77.
  95.  
  96.      HELP is the source text for the help facility.  It  is  read
  97. by  the  sequential version of HELPER, or preprocessed by HELPSET
  98. into two files which are then read by the direct  access  version
  99. of  HELPER.   HELP  is also included as an appendix in the User's
  100. Guide.
  101.  
  102.      The subroutines in one of the versions of SYS may have to be
  103. modified for your particular operating system.  They involve file
  104. access and floating point word format.  I have included  versions
  105. that  should  work  on several different operating systems.  Pick
  106. the version that is closest to  your  own  system  and  make  any
  107. changes you need.  There are no machine dependent constants.
  108.  
  109.      DOC is a report entitled "MATLAB Users' Guide".   It  should
  110. be printed on a nice printer with upper and lower case; there are
  111. 66 lines per page.  Make as many copies as  you  need,  or  order
  112. copies from us at New Mexico.
  113.  
  114.      DEMO  contains  a  demonstration  exec  file  which  can  be
  115. accessed by the exec command in MATLAB. On most systems, all that
  116. is required is EXEC('DEMO') or EXEC('DEMO',7).  On some  systems,
  117. like  TSO  and  NOS,  it will be necessary to attach file DEMO to
  118. unit 2 and then EXEC(2) or EXEC(2,7).
  119.  
  120.      DOC.NROFF is the input to the UNIX  text  processing  system
  121. that  was used to produce DOC.  This may be useful if you want to
  122. print the users' guide in a different format.
  123.  
  124.      MAT.SNGL and LIB.SNGL are the single precision  versions  of
  125. MAT  and LIB.  It is suggested that these be used only on systems
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135. MATLAB Installation, page 3
  136.  
  137.  
  138.  
  139. with long  words  (48  bit  floating  point  fraction)  or  small
  140. memories.
  141.  
  142.      The first thing to worry about is the character set. The use
  143. of an upper-lower case character set is highly desirable, but not
  144. essential.  Read the tape and look at the first 50 or so lines of
  145. MAT.  This  is  the  subroutine  MATLAB,  a  listing  of which is
  146. included in this document. Check the comments near the  beginning
  147. to  see  if  the special characters are ok.  The ones we have had
  148. trouble with include:
  149.         SEMI ;   BSLASH    COLON :   LESS <   GREAT >
  150. Any characters which are not ok should be changed in the  comment
  151. and  in the data statement which follows. The alternate character
  152. set includes the lower case letters as well  as  substitutes  for
  153. some of the special characters, such as  and :, which are not on
  154. some terminals.  Do  not  worry  too  much  about  the  alternate
  155. character  set  now.   These data statements in subroutine MATLAB
  156. are  the  only  place  in  the  source  code  where  the  special
  157. characters  occur.   (If  you  want to get fancy, there is a data
  158. statement involving BEL in subroutine ERROR near the end of  file
  159. MAT.   Change  1H-blank  to  1H-control G to get your terminal to
  160. ring its bell for any error.)
  161.  
  162.      The files DOC and  HELP  are  full  of  special  characters,
  163. including
  164.           <   >   \   !   :   ;      
  165. If they are not ok, I hope it is not too difficult  to  fix  them
  166. up.
  167.  
  168.      I have used several FORTRAN  constructions  which  are  only
  169. semi-standard, and which may have to be changed for some systems:
  170.   Single quote (') in FORMATS instead of a tribute to Hollerith.
  171.   Entire arrays initialized in DATA statements.
  172.   Use of END= in READ statements.
  173. I have not asked PFORT to tell me what else is non-standard.
  174.  
  175.      Some interactive FORTRAN systems use column 1  for  carriage
  176. control and others don't.  If your system does not, edit file MAT
  177. and delete all "1X," .  There are 131 occurrences.
  178.  
  179.      The main program in file SYS simply  calls  MATLAB.  It  may
  180. have  to  be  modified  to  control the printing of underflow and
  181. overflow  messages.   The  ground  rules  are:   Underflows   are
  182. possible,  but  are  harmless  if  they  are quietly set to zero.
  183. Overflows are error conditions.  It would  be  nice  to  print  a
  184. message and continue.
  185.  
  186.      A listing of a typical version of SYS, using some Fortran 77
  187. for  clarity,  is included in this document.  I hope it is fairly
  188. easy to see what the various subroutines do and how they have  to
  189. be  revised  for  your  system. Please send me copies of versions
  190. appropriate for your system.
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201. MATLAB Installation, page 4
  202.  
  203.  
  204.  
  205.      The amount of memory required can be  altered  by  a  global
  206. text  edit  on  MAT which changes the matrix element stack length
  207. from 5005 to something else.  Be sure to get the statement
  208.           VSIZE = 5005
  209. in the subroutine MATLAB.  With this setting of the stack length,
  210. MATLAB  requires  about  a 300K byte region on an IBM system. The
  211. length has to be reduced somewhat to get MATLAB to fit into a 64K
  212. word  region on a CDC system.  Since each matrix element occupies
  213. two double or single precision words, an increase of 1000 in  the
  214. stack length requires an additional 16K bytes or 2000 words.
  215.  
  216.      It is possible to  get  by  with  less  memory  if  you  use
  217. overlays.  The simplest way to do this is the following.
  218.  
  219.                    ROOT
  220.                      
  221.       -------------------------------
  222.                                
  223.      S0    S1    S2    S3    S4    S5
  224.  
  225. Only ROOT plus one of the segments  S0  through  S5  need  be  in
  226. memory at any one time.  The segments do not call each other, but
  227. return to the root.  All the relevant calls are near the  end  of
  228. subroutine  MATLAB  in  the  root.  There are five labeled COMMON
  229. blocks which are shared by the root and all  the  segments.   The
  230. various segments consist of:
  231.  
  232.       ROOT:
  233.         MAIN        MATLAB      STACK1
  234.         PRINT       PRNTID      FUNS
  235.         STACKP      ERROR       FILES
  236.         HELPER      PYTHAG      FORMZ
  237.         FLOP        PROMPT
  238.         Plus everything in file LIB not mentioned below.
  239.  
  240.       S0:
  241.         PARSE       COMAND      CLAUSE
  242.         EXPR        TERM        FACTOR
  243.         STACKG      STACK2      GETSYM
  244.         GETLIN      GETCH       GETVAL
  245.         EDIT        XCHAR
  246.  
  247.       S1:
  248.         MATFN1      WGECO       WGEFA
  249.         WGESL       WGEDI       WPOFA
  250.         RREF        HILBER
  251.  
  252.       S2:
  253.         MATFN2      CORTH       COMQR3
  254.         HTRIDI      HTRIBK      IMTQL2
  255.  
  256.       S3:
  257.         MATFN3      WSVDC
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267. MATLAB Installation, page 5
  268.  
  269.  
  270.  
  271.       S4:
  272.         MATFN4      WQRDC       WQRSL
  273.  
  274.       S5:
  275.         MATFN5      MATFN6      MAGIC
  276.         SAVLOD      RAT         USER
  277.         PLOT
  278.  
  279. If you have enough room, combine ROOT and S0.   With  more  room,
  280. combine  ROOT,  S0  and  S5.   If you use some overlay structure,
  281. please send me a description of how it is done on your system.
  282.  
  283.      In  case  anybody  needs  to  know,  here  are  the  changes
  284. necessary  to  convert from double to single precision.  They can
  285. all be safely accomplished by simple global text changes in  MAT,
  286. LIB and an appropriate version of SYS.
  287.  
  288.       DOUBLE PRECISION   REAL
  289.       DOUBLE-            REAL-
  290.       DSQRT              SQRT
  291.       DLOG               ALOG
  292.       DEXP               EXP
  293.       DSIN               SIN
  294.       DCOS               COS
  295.       DATAN              ATAN
  296.       DABS               ABS
  297.       DMAX1              AMAX1
  298.       DMIN1              AMIN1
  299.       IDINT              IFIX
  300.       DSIGN              SIGN
  301.       DMOD               AMOD
  302.       D0                 E0
  303.       D1                 E1
  304.       D2                 E2
  305.       D9                 E9
  306.  
  307.  
  308.      Here are some additional comments that apply  to  individual
  309. systems.
  310.  
  311.  
  312. VAX UNIX.
  313.  
  314.      If you have read the "tar" format tape, see file README  and
  315. the makefile.  Ignore the rest of this section.
  316.  
  317.      It is essential to change the single backslash  in the data
  318. statement  near  the  beginning of file MAT to a double backslash
  319. .  If this is not done, the F77 compiler  produces  an  obscure
  320. error message about "dataalpha" being too long.
  321.  
  322.      Increase the size of the stack  to  take  advantage  of  the
  323. virtual  memory.  Eliminate  all the "1X," in formats. Change the
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333. MATLAB Installation, page 6
  334.  
  335.  
  336.  
  337. statement CASE = 0 in MATLAB to CASE = 1 to get lower  case  file
  338. names.   All  these  changes  can be accomplished by applying the
  339. following ed or vi commands to file MAT.
  340.  
  341.         1,$s///g
  342.         1,$s/5005/50005/g
  343.         1,$s/1X,/0X,/g
  344.         1,$s/CASE = 0/CASE = 1/
  345.         1,$s/BEL/1H /BEL/1H^G/
  346.         1,$s/LCT(2) = 25/LCT(2) = 25000/
  347.  
  348.      The compilation should suppress warnings about  initializing
  349. non-character   variables  with  Hollerith  and  should  use  the
  350. Berkeley version of  the  i/o  support  routines.   This  can  be
  351. accomplished with:
  352.  
  353.       % f77 -w66 mat.f lib.f helper.f sys.f -lI77uc
  354.  
  355.      Gary Klimowicz and Lee Ward of UNM have developed a overflow
  356. fault  handler  for use with VAX UNIX.  A copy of their C program
  357. in included in SYS.UNIX and on the "tar" tape.
  358.  
  359.  
  360.  
  361. VAX VMS
  362.  
  363.      SYS.VMS contains an extra subroutine for proper handling  of
  364. floating point overflow.  The main program includes a call to the
  365. system which initializes this handling.
  366.  
  367.      Integer overflow is expected in the the print routine and in
  368. random  number  generator.   The integer overflow messages can be
  369. turned off by
  370.  
  371.      FORTRAN/NOCHECK  MAT.FOR,LIB.FOR
  372.  
  373.  
  374.  
  375. IBM (TSO)
  376. (Thanks to Jack Dongarra at Argonne.)
  377.  
  378.      The main program in SYS.TSO includes the  appropriate  calls
  379. to the IBM system utility ERRSET that turns off verbose underflow
  380. and overflow messages.
  381.  
  382.      Unfortunately, TSO does not have  a  mechanism  for  opening
  383. files during execution.  It is necessary to use file numbers with
  384. SAVE, LOAD and EXEC.
  385.  
  386.      We have to specify LRECL=80 for terminal input on unit 5  to
  387. get  blanks  added to input lines.  It is a good idea to set up a
  388. clist something like the following.
  389.  
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399. MATLAB Installation, page 7
  400.  
  401.  
  402.  
  403.       FREE FILE(FT05F001 FT06F001 FT09F001 FT01F001 FT02F001)
  404.       FREE ATTRLIST(AT80)
  405.       ATTR  AT80 LRECL(80) BLKSIZE(80) RECFM(F)
  406.       ALLOC FILE(FT05F001) DA(*) USING(AT80)
  407.       ALLOC FILE(FT06F001) DA(*)
  408.       ALLOC FILE(FT09F001) DA('MATLAB.HELP.DATA')
  409.       ALLOC FILE(FT01F001) DA(SAVLOD.DATA)
  410.       ALLOC FILE(FT02F001) DA('MATLAB.DEMO.DATA')
  411.       CALL 'MATLAB.LOAD(MATMOD)'
  412.  
  413. With this arrangement, the DEMO file can be executed by  exec(2).
  414.  
  415.  
  416.  
  417. IBM (CMS)
  418. (Thanks to Jack Dongarra at Argonne and David Gay at MIT.)
  419.  
  420.      Entering a blank line  in  response  to  the  MATLAB  prompt
  421. generates  an  end-of-file  from  terminal  input  (Fortran  unit
  422. FT05F001). This results in a call from GETLIN to FILES with LUNIT
  423. =  -5.  The terminal is "rewound" and control eventually returned
  424. to PARSE which prints another prompt.  I hope this works.
  425.  
  426.      An assembly language routine used to attach files with names
  427. generated  by  MATLAB  to  Fortran  unit  numbers  is included in
  428. SYS.CMS.
  429.  
  430.  
  431.  
  432. DEC-10
  433. (Thanks to Stan Eisenstat and Craig Douglas at Yale.)
  434.  
  435.      The  hyperbolic  trig  functions  SINH  and  COSH  are   not
  436. available on the DEC system.  Fortran subroutines are included in
  437. the SYS.DEC10 file.
  438.  
  439.  
  440.  
  441. PRIME 400
  442. (Thanks to Richard Franke and Drexel University.)
  443.  
  444.      The terminal is  Fortran  I/O  unit  number  1.   Subroutine
  445. MATLAB has to be changed so that
  446.       RTE = 5  becomes  RTE = 1
  447.       WTE = 6  becomes  WTE = 1
  448. Subroutine MATFN5 has to be changed so that
  449.       WIO = 1  becomes  WIO = 8
  450.       LUNIT = 1  becomes  LUNIT = 8  (in two places).
  451.  
  452.  
  453.  
  454. CDC
  455.  
  456.  
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.  
  464.  
  465. MATLAB Installation, page 8
  466.  
  467.  
  468.  
  469.      CDC systems offer exciting challenges as far as  portability
  470. is  concerned.  The first question is: which character set should
  471. be used?  An easy  approach  is  to  convert  everything  to  the
  472. venerable  6-bit  character  set.   Even so, you may have trouble
  473. with the colon, which is a pretty important MATLAB character.  It
  474. is  far  more  fun to try to use upper and lower case and all the
  475. special symbols.  I have succeeded in doing this with  the  6/12-
  476. bit  setup  used  on  the NOS system at Sandia, but have given up
  477. with the 6/18-bit coding on LTSS at Los Alamos.
  478.  
  479.      In  "ASCII"  mode  on  NOS,  lower   case   characters   are
  480. represented  by  12 bits -- the first 6 bits are octal 76 and the
  481. last 6 are the corresponding upper case character.  They count as
  482. two  characters.   So, the following changes are required in file
  483. MAT.  Several of the mixed  case  strings  in  FORMAT  statements
  484. extend  beyond column 72.  You might as well convert these to all
  485. upper case.  All the 80A1's  in  FORMATS  should  be  changed  to
  486. 132A1's  and all the DATA statements initializing LRECL should be
  487. changed from  80  to  132.   The  DATA  statement  for  ALPHB  in
  488. subroutine   MATLAB  can  be  changed  to  have  all  upper  case
  489. alphabetic characters because subroutine  XCHAR  will  catch  the
  490. prefix octal 76.
  491.  
  492.      An important change involves our  friend  the  colon,  which
  493. becomes  a  12-bit  octal 7404.  In the DATA statement for ALPHA,
  494. make the element just before 1H+ into a 1H(percent  sign).   And,
  495. in  the  DATA statement for ALPHB, make the corresponding element
  496. into a 2H(colon).  Then read the comments in subroutine XCHAR  in
  497. file  SYS.CDC  and  make  sure that the DATA statements there are
  498. correct.
  499.  
  500.      The FTN5 compiler should take MATLAB pretty much is  it  is.
  501. The  older  FTN  compiler  requires  two  familiar changes to the
  502. entire source code.  First, the END= in the READ statements  have
  503. to be replaced by IF (EOF) GO TO ... .  Second, the single quotes
  504. in FORMATS have to be replaced with asterisks.
  505.  
  506.  
  507.  
  508. Good luck.  Please let me know what difficulties  you  have,  and
  509. what I have left out of this guide.  You can call me at:
  510.          505-268-8631  (home)
  511.          505-277-3112  (office)
  512.  
  513. ------------
  514.  
  515.      The support of the National Science Foundation and  the  use
  516. of facilities at Argonne National Laboratory, Los Alamos National
  517. Laboratory and Stanford Linear Accelerator Center  is  gratefully
  518. acknowledged.   So  is the assistance of the many people who have
  519. installed early versions of MATLAB.
  520.  
  521.  
  522.  
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531. MATLAB Installation, page 9
  532.  
  533.  
  534.  
  535. Contents of file MAT:
  536.  
  537.       SUBROUTINE MATLAB(INIT)
  538.       SUBROUTINE PARSE
  539.       SUBROUTINE COMAND(ID)
  540.       SUBROUTINE CLAUSE
  541.       SUBROUTINE EXPR
  542.       SUBROUTINE TERM
  543.       SUBROUTINE FACTOR
  544.       SUBROUTINE FUNS(ID)
  545.       SUBROUTINE STACKP(ID)
  546.       SUBROUTINE STACKG(ID)
  547.       SUBROUTINE STACK1(OP)
  548.       SUBROUTINE STACK2(OP)
  549.       SUBROUTINE PRINT(ID,K)
  550.       SUBROUTINE PRNTID(ID,ARGCNT)
  551.       SUBROUTINE GETSYM
  552.       SUBROUTINE GETLIN
  553.       SUBROUTINE GETCH
  554.       SUBROUTINE GETVAL(S)
  555.       SUBROUTINE MATFN1
  556.       SUBROUTINE MATFN2
  557.       SUBROUTINE MATFN3
  558.       SUBROUTINE MATFN4
  559.       SUBROUTINE MATFN5
  560.       SUBROUTINE MATFN6
  561.       SUBROUTINE ERROR(N)
  562.       DOUBLE PRECISION FUNCTION PYTHAG(A,B)
  563.       SUBROUTINE RAT(X,LEN,MAXD,D)
  564.  
  565. Contents of file HELPER.66:
  566.  
  567.       SUBROUTINE HELPER(H) -- Sequential version
  568.  
  569. Contents of file HELPER.77:
  570.  
  571.       PROGRAM HLPSET       -- Direct access setup
  572.       SUBROUTINE HELPER(H) -- Direct access version
  573.  
  574. Contents of file SYS:
  575.  
  576.       PROGRAM MAIN
  577.       SUBROUTINE FILES(LUNIT,NAME)
  578.       SUBROUTINE SAVLOD(LUNIT,ID,M,N,IMG,JOB,XREAL,XIMAG)
  579.       SUBROUTINE FORMZ(LUNIT,X,Y)
  580.       DOUBLE PRECISION FUNCTION FLOP(X)
  581.       SUBROUTINE XCHAR(BUF,K)
  582.       SUBROUTINE USER(A,M,N,S,T)
  583.       SUBROUTINE PROMPT(PAUSE)
  584.       SUBROUTINE PLOT(LUNIT,X,Y,N,P,K,BUF)
  585.       SUBROUTINE EDIT(BUF,N)
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597. MATLAB Installation, page 10
  598.  
  599.  
  600.  
  601. Contents of file LIB:
  602.  
  603.       SUBROUTINE WGECO(AR,AI,LDA,N,IPVT,RCOND,ZR,ZI)
  604.       SUBROUTINE WGEFA(AR,AI,LDA,N,IPVT,INFO)
  605.       SUBROUTINE WGESL(AR,AI,LDA,N,IPVT,BR,BI,JOB)
  606.       SUBROUTINE WGEDI(AR,AI,LDA,N,IPVT,DETR,DETI,WORKR,WORKI,JOB)
  607.       SUBROUTINE WPOFA(AR,AI,LDA,N,INFO)
  608.       SUBROUTINE RREF(AR,AI,LDA,M,N,EPS)
  609.       SUBROUTINE HILBER(A,LDA,N)
  610.       SUBROUTINE HTRIDI(NM,N,AR,AI,D,E,E2,TAU)
  611.       SUBROUTINE HTRIBK(NM,N,AR,AI,TAU,M,ZR,ZI)
  612.       SUBROUTINE IMTQL2(NM,N,D,E,Z,IERR,JOB)
  613.       SUBROUTINE CORTH(NM,N,LOW,IGH,AR,AI,ORTR,ORTI)
  614.       SUBROUTINE COMQR3(NM,N,LOW,IGH,ORTR,ORTI,HR,HI,WR,WI,ZR,ZI,IERR
  615.       SUBROUTINE WSVDC(XR,XI,LDX,N,P,SR,SI,ER,EI,UR,UI,LDU,VR,VI,LDV,
  616.       SUBROUTINE WQRDC(XR,XI,LDX,N,P,QRAUXR,QRAUXI,JPVT,WORKR,WORKI,
  617.       SUBROUTINE WQRSL(XR,XI,LDX,N,K,QRAUXR,QRAUXI,YR,YI,QYR,QYI,QTYR,
  618.       SUBROUTINE MAGIC(A,LDA,N)
  619.       SUBROUTINE BASE(X,B,EPS,S,N)
  620.       DOUBLE PRECISION FUNCTION URAND(IY)
  621.       SUBROUTINE WMUL(AR,AI,BR,BI,CR,CI)
  622.       SUBROUTINE WDIV(AR,AI,BR,BI,CR,CI)
  623.       SUBROUTINE WSIGN(XR,XI,YR,YI,ZR,ZI)
  624.       SUBROUTINE WSQRT(XR,XI,YR,YI)
  625.       SUBROUTINE WLOG(XR,XI,YR,YI)
  626.       SUBROUTINE WATAN(XR,XI,YR,YI)
  627.       DOUBLE PRECISION FUNCTION WNRM2(N,XR,XI,INCX)
  628.       DOUBLE PRECISION FUNCTION WASUM(N,XR,XI,INCX)
  629.       INTEGER FUNCTION IWAMAX(N,XR,XI,INCX)
  630.       SUBROUTINE WRSCAL(N,S,XR,XI,INCX)
  631.       SUBROUTINE WSCAL(N,SR,SI,XR,XI,INCX)
  632.       SUBROUTINE WAXPY(N,SR,SI,XR,XI,INCX,YR,YI,INCY)
  633.       DOUBLE PRECISION FUNCTION WDOTUR(N,XR,XI,INCX,YR,YI,INCY)
  634.       DOUBLE PRECISION FUNCTION WDOTUI(N,XR,XI,INCX,YR,YI,INCY)
  635.       DOUBLE PRECISION FUNCTION WDOTCR(N,XR,XI,INCX,YR,YI,INCY)
  636.       DOUBLE PRECISION FUNCTION WDOTCI(N,XR,XI,INCX,YR,YI,INCY)
  637.       SUBROUTINE WCOPY(N,XR,XI,INCX,YR,YI,INCY)
  638.       SUBROUTINE WSET(N,XR,XI,YR,YI,INCY)
  639.       SUBROUTINE WSWAP(N,XR,XI,INCX,YR,YI,INCY)
  640.       SUBROUTINE RSET(N,DX,DY,INCY)
  641.       SUBROUTINE RSWAP(N,X,INCX,Y,INCY)
  642.       SUBROUTINE RROT(N,DX,INCX,DY,INCY,C,S)
  643.       SUBROUTINE RROTG(DA,DB,C,S)
  644.       LOGICAL FUNCTION EQID(X,Y)
  645.       SUBROUTINE PUTID(X,Y)
  646.       DOUBLE PRECISION FUNCTION ROUND(X)
  647.  
  648.  
  649.  
  650.  
  651.  
  652.  
  653.  
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.  
  661.  
  662.  
  663. MATLAB Installation, page 11
  664.  
  665.  
  666.  
  667. First subroutine in file MAT:
  668.  
  669.       SUBROUTINE MATLAB(INIT)
  670. C     INIT = 0 FOR ORDINARY FIRST ENTRY
  671. C          = POSITIVE FOR SUBSEQUENT ENTRIES
  672. C          = NEGATIVE FOR SILENT INITIALIZATION (SEE MATZ)
  673. C
  674.       DOUBLE PRECISION STKR(5005),STKI(5005)
  675.       INTEGER IDSTK(4,48),LSTK(48),MSTK(48),NSTK(48),VSIZE,LSIZE,BOT,TOP
  676.       INTEGER ALFA(52),ALFB(52),ALFL,CASE
  677.       INTEGER IDS(4,32),PSTK(32),RSTK(32),PSIZE,PT,PTZ
  678.       INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE,HIO
  679.       INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2)
  680.       COMMON /VSTK/ STKR,STKI,IDSTK,LSTK,MSTK,NSTK,VSIZE,LSIZE,BOT,TOP
  681.       COMMON /ALFS/ ALFA,ALFB,ALFL,CASE
  682.       COMMON /RECU/ IDS,PSTK,RSTK,PSIZE,PT,PTZ
  683.       COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE,HIO
  684.       COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN
  685. C
  686.       DOUBLE PRECISION S,T
  687.       INTEGER EPS(4),FLOPS(4),EYE(4),RAND(4)
  688. C
  689. C     CHARACTER SET
  690. C            0       10       20       30       40       50
  691. C
  692. C     0      0        A        K        U   COLON  :  LESS   <
  693. C     1      1        B        L        V   PLUS   +  GREAT  >
  694. C     2      2        C        M        W   MINUS  -
  695. C     3      3        D        N        X   STAR   *
  696. C     4      4        E        O        Y   SLASH  /
  697. C     5      5        F        P        Z   BSLASH 
  698. C     6      6        G        Q  BLANK     EQUAL  =
  699. C     7      7        H        R  LPAREN (  DOT    .
  700. C     8      8        I        S  RPAREN )  COMMA  ,
  701. C     9      9        J        T  SEMI   ;  QUOTE  '
  702. C
  703.       INTEGER ALPHA(52),ALPHB(52)
  704.       DATA ALPHA /1H0,1H1,1H2,1H3,1H4,1H5,1H6,1H7,1H8,1H9,
  705.      $    1HA,1HB,1HC,1HD,1HE,1HF,1HG,1HH,1HI,1HJ,
  706.      $    1HK,1HL,1HM,1HN,1HO,1HP,1HQ,1HR,1HS,1HT,
  707.      $    1HU,1HV,1HW,1HX,1HY,1HZ,1H ,1H(,1H),1H;,
  708.      $    1H:,1H+,1H-,1H*,1H/,1H,1H=,1H.,1H,,1H',
  709.      $    1H<,1H>/
  710. C
  711. C     ALTERNATE CHARACTER SET
  712. C
  713.       DATA ALPHB /1H0,1H1,1H2,1H3,1H4,1H5,1H6,1H7,1H8,1H9,
  714.      $    1Ha,1Hb,1Hc,1Hd,1He,1Hf,1Hg,1Hh,1Hi,1Hj,
  715.      $    1Hk,1Hl,1Hm,1Hn,1Ho,1Hp,1Hq,1Hr,1Hs,1Ht,
  716.      $    1Hu,1Hv,1Hw,1Hx,1Hy,1Hz,1H ,1H(,1H),1H;,
  717.      $    1H,1H+,1H-,1H*,1H/,1H$,1H=,1H.,1H,,1H",
  718.      $    1H\,1H!/
  719. C
  720.  
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729. MATLAB Installation, page 12
  730.  
  731.  
  732.  
  733.       DATA EPS/14,25,28,36/,FLOPS/15,21,24,25/
  734.       DATA EYE/14,34,14,36/,RAND/27,10,23,13/
  735. C
  736.       IF (INIT .GT. 0) GO TO 90
  737. C
  738. C     RTE = UNIT NUMBER FOR TERMINAL INPUT
  739. C     WTE = UNIT NUMBER FOR TERMINAL OUTPUT
  740. C     HIO = UNIT NUMBER FOR HELP FILE
  741.       RTE = 5
  742.       WTE = 6
  743.       HIO = 9
  744. C
  745.       IF (INIT .GE. 0) WRITE(WTE,100)
  746.   100 FORMAT(//1X,'     < M A T L A B >'
  747.      $  /1X,'   Version of --/--/--')
  748. C
  749. C     ASK HELPER TO OPEN HELP FILE
  750.       BUF(1) = 0
  751.       CALL HELPER(BUF)
  752. C
  753. C     RANDOM NUMBER SEED
  754.       RAN(1) = 0
  755. C
  756. C     INITIAL LINE LIMIT
  757.       LCT(2) = 25
  758. C
  759.       ALFL = 52
  760.       CASE = 1
  761. C     CASE = 1 for file names in lower case
  762.       DO 20 I = 1, ALFL
  763.          ALFA(I) = ALPHA(I)
  764.          ALFB(I) = ALPHB(I)
  765.    20 CONTINUE
  766. C
  767.       VSIZE = 50005
  768.       LSIZE = 48
  769.       PSIZE = 32
  770.       BOT = LSIZE-3
  771.       CALL WSET(5,0.0D0,0.0D0,STKR(VSIZE-4),STKI(VSIZE-4),1)
  772.       CALL PUTID(IDSTK(1,LSIZE-3),EPS)
  773.       LSTK(LSIZE-3) = VSIZE-4
  774.       MSTK(LSIZE-3) = 1
  775.       NSTK(LSIZE-3) = 1
  776.       S = 1.0D0
  777.    30 S = S/2.0D0
  778.       T = 1.0D0 + S
  779.       IF (T .GT. 1.0D0) GO TO 30
  780.       STKR(VSIZE-4) = 2.0D0*S
  781.       CALL PUTID(IDSTK(1,LSIZE-2),FLOPS)
  782.       LSTK(LSIZE-2) = VSIZE-3
  783.       MSTK(LSIZE-2) = 1
  784.       NSTK(LSIZE-2) = 2
  785.       CALL PUTID(IDSTK(1,LSIZE-1), EYE)
  786.  
  787.  
  788.  
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795. MATLAB Installation, page 13
  796.  
  797.  
  798.  
  799.       LSTK(LSIZE-1) = VSIZE-1
  800.       MSTK(LSIZE-1) = -1
  801.       NSTK(LSIZE-1) = -1
  802.       STKR(VSIZE-1) = 1.0D0
  803.       CALL PUTID(IDSTK(1,LSIZE), RAND)
  804.       LSTK(LSIZE) = VSIZE
  805.       MSTK(LSIZE) = 1
  806.       NSTK(LSIZE) = 1
  807.       FMT = 1
  808.       FLP(1) = 0
  809.       FLP(2) = 0
  810.       DDT = 0
  811.       RAN(2) = 0
  812.       PTZ = 0
  813.       PT = PTZ
  814.       ERR = 0
  815.       RIO = RTE
  816.       WIO = 0
  817.       IF (INIT .LT. 0) RETURN
  818. C
  819.    90 CALL PARSE
  820.       IF (FUN .EQ. 1) CALL MATFN1
  821.       IF (FUN .EQ. 2) CALL MATFN2
  822.       IF (FUN .EQ. 3) CALL MATFN3
  823.       IF (FUN .EQ. 4) CALL MATFN4
  824.       IF (FUN .EQ. 5) CALL MATFN5
  825.       IF (FUN .EQ. 6) CALL MATFN6
  826.       IF (FUN .EQ. 21) CALL MATFN1
  827.       IF (FUN .NE. 99) GO TO 90
  828.       RETURN
  829.       END
  830.  
  831.  
  832.  
  833.  
  834.  
  835.  
  836.  
  837.  
  838.  
  839.  
  840.  
  841.  
  842.  
  843.  
  844.  
  845.  
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854.  
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861. MATLAB Installation, page 14
  862.  
  863.  
  864.  
  865. Typical file SYS (Nonstandard stuff in lower case):
  866.  
  867. C     PROGRAM MAIN
  868.       call overflow-control
  869.       CALL MATLAB(0)
  870.       STOP
  871.       END
  872.  
  873.  
  874.       SUBROUTINE FILES(LUNIT,NAME)
  875.       INTEGER LUNIT,NAME(32)
  876. C
  877. C     SYSTEM DEPENDENT ROUTINE TO ALLOCATE FILES
  878. C     LUNIT = LOGICAL UNIT NUMBER
  879. C     NAME = FILE NAME, 1 CHARACTER PER WORD
  880. C
  881.       character*32 nam
  882. c
  883. c     close exec, save, load and print files
  884.       if (lunit .lt. 0) then
  885.          close(unit=-lunit)
  886.          return
  887.       end if
  888. c
  889. c     Fortran 77 internal file conversion from 32a1 to character*32
  890.       write(nam,'(32a1)') name
  891. c
  892. c     formatted i/o for exec and print
  893.       if (lunit .gt. 2) open(unit=lunit,file=nam)
  894. c
  895. c     unformatted i/o for save and load
  896.       if (lunit .le. 2) open(unit=lunit,file=nam,form='unformatted')
  897. c
  898. c     rewind all except diary
  899.       if (lunit .ne. 8) rewind lunit
  900. c
  901.       RETURN
  902.       END
  903.  
  904.  
  905.       SUBROUTINE SAVLOD(LUNIT,ID,M,N,IMG,JOB,XREAL,XIMAG)
  906.       INTEGER LUNIT,ID(4),M,N,IMG,JOB
  907.       DOUBLE PRECISION XREAL(1),XIMAG(1)
  908. C
  909. C     IMPLEMENT SAVE AND LOAD
  910. C     LUNIT = LOGICAL UNIT NUMBER
  911. C     ID = NAME, FORMAT 4A1
  912. C     M, N = DIMENSIONS
  913. C     IMG = NONZERO IF XIMAG IS NONZERO
  914. C     JOB = 0     FOR SAVE
  915. C         = SPACE AVAILABLE FOR LOAD
  916. C     XREAL, XIMAG = REAL AND OPTIONAL IMAGINARY PARTS
  917. C
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927. MATLAB Installation, page 15
  928.  
  929.  
  930.  
  931. C     THIS VERSION USES UNFORMATTED READ AND WRITE
  932. C
  933.       IF (JOB .GT. 0) GO TO 20
  934. C
  935. C     SAVE
  936.    10 WRITE(LUNIT) ID,M,N,IMG
  937.       DO 15 J = 1, N
  938.          K = (J-1)*M+1
  939.          L = J*M
  940.          WRITE(LUNIT) (XREAL(I),I=K,L)
  941.          IF (IMG .NE. 0) WRITE(LUNIT) (XIMAG(I),I=K,L)
  942.    15 CONTINUE
  943.       RETURN
  944. C
  945. C     LOAD
  946.    20 READ(LUNIT,END=30) ID,M,N,IMG
  947.       IF (M*N .GT. JOB) GO TO 30
  948.       DO 25 J = 1, N
  949.          K = (J-1)*M+1
  950.          L = J*M
  951.          READ(LUNIT,END=30) (XREAL(I),I=K,L)
  952.          IF (IMG .NE. 0) READ(LUNIT,END=30) (XIMAG(I),I=K,L)
  953.    25 CONTINUE
  954.       RETURN
  955. C
  956. C     END OF FILE
  957.    30 M = 0
  958.       N = 0
  959.       RETURN
  960.       END
  961.  
  962.  
  963.       SUBROUTINE FORMZ(LUNIT,X,Y)
  964.       DOUBLE PRECISION X,Y
  965. C
  966. C     SYSTEM DEPENDENT ROUTINE TO PRINT WITH Z FORMAT
  967. C
  968.       IF (Y .NE. 0.0D0) WRITE(LUNIT,10) X,Y
  969.       IF (Y .EQ. 0.0D0) WRITE(LUNIT,10) X
  970.    10 format(2z18)
  971.       RETURN
  972.       END
  973.  
  974.  
  975.       DOUBLE PRECISION FUNCTION FLOP(X)
  976.       DOUBLE PRECISION X
  977. C     SYSTEM DEPENDENT FUNCTION
  978. C     COUNT AND POSSIBLY CHOP EACH FLOATING POINT OPERATION
  979. C     FLP(1) IS FLOP COUNTER
  980. C     FLP(2) IS NUMBER OF PLACES TO BE CHOPPED
  981. C
  982.       INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2)
  983.       COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993. MATLAB Installation, page 16
  994.  
  995.  
  996.  
  997. C
  998.       double precision mask(14),xx,mm
  999.       real mas(2,14)
  1000.       logical lx(2),lm(2)
  1001.       equivalence (lx(1),xx),(lm(1),mm)
  1002.       equivalence (mask(1),mas(1))
  1003.       data mas/
  1004.      $ z'ffffffff',z'fff0ffff',
  1005.      $ z'ffffffff',z'ff00ffff',
  1006.      $ z'ffffffff',z'f000ffff',
  1007.      $ z'ffffffff',z'0000ffff',
  1008.      $ z'ffffffff',z'0000fff0',
  1009.      $ z'ffffffff',z'0000ff00',
  1010.      $ z'ffffffff',z'0000f000',
  1011.      $ z'ffffffff',z'00000000',
  1012.      $ z'fff0ffff',z'00000000',
  1013.      $ z'ff00ffff',z'00000000',
  1014.      $ z'f000ffff',z'00000000',
  1015.      $ z'0000ffff',z'00000000',
  1016.      $ z'0000fff0',z'00000000',
  1017.      $ z'0000ff80',z'00000000'/
  1018. C
  1019.       FLP(1) = FLP(1) + 1
  1020.       K = FLP(2)
  1021.       FLOP = X
  1022.       IF (K .LE. 0) RETURN
  1023.       FLOP = 0.0D0
  1024.       IF (K .GE. 15) RETURN
  1025.       XX = X
  1026.       MM = MASK(K)
  1027.       LX(1) = and(LX(1),LM(1))
  1028.       LX(2) = and(LX(2),LM(2))
  1029.       FLOP = XX
  1030.       RETURN
  1031.       END
  1032.  
  1033.  
  1034.       SUBROUTINE XCHAR(BUF,K)
  1035.       INTEGER BUF(1),K
  1036. C
  1037. C     SYSTEM DEPENDENT ROUTINE TO HANDLE SPECIAL CHARACTERS
  1038. C
  1039.       INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE
  1040.       COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE
  1041.       write(WTE,10) buf(1)
  1042.    10 format(A1,' is not a MATLAB character.')
  1043.       RETURN
  1044.       END
  1045.  
  1046.  
  1047.       SUBROUTINE USER(A,M,N,S,T)
  1048.       DOUBLE PRECISION A(M,N),S,T
  1049. C
  1050.  
  1051.  
  1052.  
  1053.  
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059. MATLAB Installation, page 17
  1060.  
  1061.  
  1062.  
  1063.       INTEGER A3(9)
  1064.       DATA A3 /-149,537,-27,-50,180,-9,-154,546,-25/
  1065.       IF (A(1,1) .NE. 3.0D0) RETURN
  1066.       DO 10 I = 1, 9
  1067.          A(I,1) = A3(I)
  1068.    10 CONTINUE
  1069.       M = 3
  1070.       N = 3
  1071.       RETURN
  1072.       END
  1073.  
  1074.  
  1075.       SUBROUTINE PROMPT(PAUSE)
  1076.       INTEGER PAUSE
  1077. C
  1078. C     ISSUE MATLAB PROMPT WITH OPTIONAL PAUSE
  1079. C
  1080.       INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE
  1081.       COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE
  1082.       WRITE(WTE,10)
  1083.       IF (WIO .NE. 0) WRITE(WIO,10)
  1084.    10 FORMAT(1X,/'<>')
  1085.       IF (PAUSE .EQ. 1) READ(RTE,20) DUMMY
  1086.    20 FORMAT(A1)
  1087.       RETURN
  1088.       END
  1089.  
  1090.  
  1091.       SUBROUTINE PLOT(LUNIT,X,Y,N,P,K,BUF)
  1092.       DOUBLE PRECISION X(N),Y(N),P(1)
  1093.       INTEGER BUF(79)
  1094. C
  1095. C     PLOT X VS. Y ON LUNIT
  1096. C     IF K IS NONZERO, THEN P(1),...,P(K) ARE EXTRA PARAMETERS
  1097. C     BUF IS WORK SPACE
  1098. C
  1099.       DOUBLE PRECISION XMIN,YMIN,XMAX,YMAX,DY,DX,Y1,Y0
  1100.       INTEGER AST,BLANK,H,W
  1101.       DATA AST/1H*/,BLANK/1H /,H/20/,W/79/
  1102. C
  1103. C     H = HEIGHT, W = WIDTH
  1104. C
  1105.       XMIN = X(1)
  1106.       XMAX = X(1)
  1107.       YMIN = Y(1)
  1108.       YMAX = Y(1)
  1109.       DO 10 I = 1, N
  1110.          XMIN = DMIN1(XMIN,X(I))
  1111.          XMAX = DMAX1(XMAX,X(I))
  1112.          YMIN = DMIN1(YMIN,Y(I))
  1113.          YMAX = DMAX1(YMAX,Y(I))
  1114.    10 CONTINUE
  1115.       DX = XMAX - XMIN
  1116.  
  1117.  
  1118.  
  1119.  
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125. MATLAB Installation, page 18
  1126.  
  1127.  
  1128.  
  1129.       IF (DX .EQ. 0.0D0) DX = 1.0D0
  1130.       DY = YMAX - YMIN
  1131.       WRITE(LUNIT,35)
  1132.       DO 40 L = 1, H
  1133.          DO 20 J = 1, W
  1134.             BUF(J) = BLANK
  1135.    20    CONTINUE
  1136.          Y1 = YMIN + (H-L+1)*DY/H
  1137.          Y0 = YMIN + (H-L)*DY/H
  1138.          JMAX = 1
  1139.          DO 30 I = 1, N
  1140.             IF (Y(I) .GT. Y1) GO TO 30
  1141.             IF (L.NE.H .AND. Y(I).LE.Y0) GO TO 30
  1142.             J = 1 + (W-1)*(X(I) - XMIN)/DX
  1143.             BUF(J) = AST
  1144.             JMAX = MAX0(JMAX,J)
  1145.    30    CONTINUE
  1146.          WRITE(LUNIT,35) (BUF(J),J=1,JMAX)
  1147.    35    FORMAT(1X,79A1)
  1148.    40 CONTINUE
  1149.       RETURN
  1150.       END
  1151.  
  1152.  
  1153.       SUBROUTINE EDIT(BUF,N)
  1154.       INTEGER BUF(N)
  1155. C
  1156. C     CALLED AFTER INPUT OF A SINGLE BACKSLASH
  1157. C     BUF CONTAINS PREVIOUS INPUT LINE, ONE CHAR PER WORD
  1158. C     ENTER LOCAL EDITOR IF POSSIBLE
  1159. C
  1160.       character*256 s
  1161.       open(7,file='----')
  1162.       write(7,10) (buf(i),i=1,n)
  1163.    10 format(256a1)
  1164.       close(7)
  1165.       call system('edit  ----')
  1166.       open(7,file='----')
  1167.       rewind 7
  1168.       read(7,'(a)') s
  1169.       close(7)
  1170.       call system('remove ----')
  1171.       n = 0
  1172.       do 20 i = 1, 256
  1173.          if (s(i:i) .ne. ' ') n = i
  1174.    20 continue
  1175.       read(s,10) (buf(i),i=1,n)
  1176.       RETURN
  1177.       END
  1178.  
  1179.  
  1180.  
  1181.  
  1182.  
  1183.  
  1184.  
  1185.  
  1186.  
  1187.  
  1188.  
  1189.